package com.browsesoft.htmlcomponent;

import java.io.Serializable;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.StringTokenizer;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.w3c.dom.Text;

import com.aote.component.InvalidDataException;
import com.aote.component.format.FormatFactory;
import com.browsesoft.Entity;
import com.browsesoft.EntityManager;
import com.browsesoft.ExtendElement;
import com.browsesoft.ManagerGroup;
import com.browsesoft.Tools;
import com.browsesoft.baseadapter.AdvancedSimpleEntity;
import com.browsesoft.baseadapter.HTMLLazyEntityModel;
import com.browsesoft.baseadapter.SimpleEntity;
import com.browsesoft.oa.BSHttpServletRequest;
import com.browsesoft.oa.BSMIMEParser;
import com.browsesoft.oa.ObjectVerifyTool;
import com.browsesoft.oa.VerifyFactory;
import com.browsesoft.oa.VerifyTool;
import com.browsesoft.user.User;

/**
 * 表单组件
 * 
 * @author Browsesoft
 * @version 1.0
 */
public class HTMLFormComponent extends ReplacableParameterComponent implements
		Serializable {
	private static final long serialVersionUID = 1L;

	/**
	 * 需要获得返回值的元素
	 */
	protected LinkedList valueFromOtherElemS = new LinkedList();

	/**
	 * 是否是只读显示
	 */
	public boolean readOnlyShow = false;

	/**
	 * 保存页面获得action
	 */
	protected String action = null;

	/**
	 * 参数传递中的ID
	 */
	protected String id = null;

	/**
	 * 表单需要处理的元素
	 */
	protected LinkedList dealElements = new LinkedList();

	protected LinkedList verifytools = new LinkedList();

	/**
	 * 签名元素要处理的元素名称集合
	 */
	protected LinkedList signsList = new LinkedList();

	protected User loginUser = null;

	private HttpServletRequest request = null;

	/**
	 * 提醒部分元素
	 */
	private Element hint = null;

	/**
	 * 构造器
	 * 
	 * @param parent
	 *            组件的父组件
	 * @throws Exception
	 */
	public HTMLFormComponent(HTMLBasicComponent parent) throws Exception {
		super(parent);
	}

	/*
	 * 初始化时 @param request @param e @throws Exception
	 */
	public void init(HttpServletRequest request, Element e) throws Exception {
		super.init(request, e);
		this.loginUser = (User) request.getSession().getAttribute("loginUser");
		// 设置日历选择
		this.setCalendar();
		// 修改需要点击另外页面的选择数据的元素
		// 替换页面中name="otherselect"的元素的onclick
		this.replaceOnClickForSelect();
		// 得到签名元素要处理的元素名称集合
		this.signsList = this.getSingElementNames();
		// 如果页面上有预设的value值，设置到页面上
		setValue();
		// 得到提示部分元素
		Element element = this.getElement();
		LinkedList ls = ExtendElement.findElements(element, "hint", "hint");
		if (ls.size() > 0) {
			this.hint = (Element) ls.get(0);
		}
		String readonly = request.getParameter("readonly");
		// 有readonly说明是查看详细信息
		if (readonly != null) {
			readOnlyShow = true;
		}
	}

	/**
	 * 替换本组件的onclick事件
	 */
	private void replaceOnClickForSelect() {
		// 找到页面中所有的name="otherselect"的元素
		valueFromOtherElemS = new LinkedList();
		Element e = this.getElement();
		valueFromOtherElemS = ExtendElement.findElements(e, "name",
				"otherselect");
		// 替换onclick ,将#compid#替换为本组件id号
		if (valueFromOtherElemS == null || valueFromOtherElemS.size() == 0) {
			return;
		}
		Iterator iter = valueFromOtherElemS.iterator();
		// 为了替换所有的onclick
		while (iter.hasNext()) {
			// 得到元素
			Element sel = (Element) iter.next();
			// 得到onclick
			String onClick = sel.getAttribute("onclick");
			// 如果onclick 不为空
			if (onClick != null && !onClick.equals("")) {
				// 替换onclick
				onClick = onClick.replaceAll("#compid#", this.getName());
				sel.setAttribute("onclick", onClick);
			}
		}
	}

	/**
	 * 读取元素e及其子元素下的要处理的元素，需要处理的元素拥有属性fieldType='typeName'
	 * 其中，typeName为该属性的数据库字段名，可以为空(fieldType='')，以表示不存入数据库中
	 * ，读出的元素以后可以使用findElement(attrName, attrValue)函数读出。
	 * 
	 * @param e
	 *            元素
	 */
	public void parseElements(Element e) throws Exception {
		if (!e.hasChildNodes()) {
			return;
		}
		for (int i = 0; i < e.getChildNodes().getLength(); i++) {
			Node ee = e.getChildNodes().item(i);
			if (ee instanceof Element) {
				// 如果有fieldType属性，则是需要处理的字段
				if (((Element) ee).hasAttribute("fieldtype")) {
					dealElements.add((Element) ee);
				}
				parseElements((Element) ee);
			}
		}
	}

	/**
	 * 根据Model的内容更新需要处理的元素内容，在产生页面时要调用 这个哈西表是
	 * 
	 * @throws java.lang.Exception
	 */
	protected void updateElement() throws Exception {
		this.dealElements.clear();
		this.parseElements(this.element);
		// 更新元素
		for (int i = 0; i < dealElements.size(); i++) {
			// 取元素的名称
			Element dealElement = (Element) dealElements.get(i);
			setFieldValue(dealElement);
		}
		// 如果是查看详细信息，就屏蔽掉页面中有提交动作的按钮
		if (readOnlyShow) {
			this.setButtonElementsAbate();
			this.removeConfirmButton();
		}
		// 设置日历的默认值
		this.setDefaultCalendar();
		// 调用父类的updateElement方法，让子组件更新
		super.updateElement();
	}

	/**
	 * 换模型
	 */
	protected void changeModel(HttpServletRequest request,
			HttpServletResponse response) {
			throw new UnsupportedOperationException();
	}

	/**
	 * 请求中没有参数时的处理
	 * 
	 * @param request
	 * @param response
	 * @throws Exception
	 */
	private void noHasParam(HttpServletRequest request, String objectName,
			String objectType, String objectValue, Hashtable hashtable) {
		// 如果是检查筐
		if (objectType.equals("checkbox")) {
			// 设置检查筐为false
			hashtable.put(objectName, "false");
		}
		// 如果是文件
		if (objectType.equals("file")) {
			// 从解析器得到文件名
			BSMIMEParser parser = (BSMIMEParser) request.getAttribute("parser");
			String realName = parser.getRealName();
			System.out.println("getStyleSheetName");
			objectValue = realName;
			System.out.println("objectValue" + objectValue);
			hashtable.put(objectName, objectValue);
		}
	}

	/**
	 * 得到请求中的参数
	 * 
	 * @param request
	 * @param response
	 * @throws Exception
	 */
	private Hashtable getParams(HttpServletRequest request) {
		BSHttpServletRequest bsrequest = (BSHttpServletRequest) request;
		Hashtable hashtable = new Hashtable();
		try {
			// 处理所有需要处理的元素
			this.dealElements.clear();
			// 得到元素fieldtype属性列表
			dealElements = ExtendElement.findElementsOfAttr(element,
					"fieldtype");
			// 找到页面中带有sign=sign标记的元素
			for (int i = 0; i < dealElements.size(); i++) {
				// 从需要处理的元素列表中得到元素
				Element dealElement = (Element) dealElements.get(i);
				// 如果不是提交,对获得返回值的元素不处理
				if ((action == null || !action.equals("confirm"))
						&& this.isOtherElement(dealElement)) {
					continue;
				}
				// 得到需要处理的元素名称
				String objectName = dealElement.getAttribute("name");
				String objectType = dealElement.getAttribute("type");
				// 如果是需要处理的元素，但没有名称，出错
				if (objectName == null) {
					throw new Exception("要处理的元素缺少名称");
				}
				// 如果请求中有值
				String objectValue = bsrequest
						.getParameterIgnoreCase(objectName);
				if(this.model instanceof SimpleEntity)
				{
					String tname = ((SimpleEntity)this.model).getTableName();
					if(tname != null && tname.equals("t_finishfeexiangxi") && request.getParameter("pagename") == null)
					{
					   objectValue = new String(objectValue.getBytes("iso8859-1"));
					}
				}		
				//System.out.println(objectValue);
				if (objectValue != null) {
					hashtable.put(objectName, objectValue);
				}
				// 否则
				else {
					// 处理无值的情况
					this.noHasParam(request, objectName, objectType,
							objectValue, hashtable);
				}		
			}
			System.out.println(hashtable.get("njcardpass"));
			return hashtable;
		} catch (Exception ex) {
			throw new RuntimeException(ex);
		}
	}

	/**
	 * 校验，返回校验是否成功
	 */
	private boolean doVerify(HttpServletRequest request, Hashtable hashtable) {
		throw new UnsupportedOperationException();
	}

	public void showErrorMessage(Hashtable hashtable) throws Exception {
		throw new UnsupportedOperationException();
	}

	/**
	 * 是否要校验
	 */
	private boolean shouldVerify(HttpServletRequest request) {
		// 有tmeplatename，第一次进入，不校验
		if (request.getParameter("templatename") != null) {
			return false;
		}
		// 如果不是提交动作，不校验
		if (this.action == null) {
			return false;
		}
		if (!this.action.equals("confirm") && !this.action.equals("next")) {
			return false;
		}
		return true;
	}

	/**
	 * 处理用户请求，将需要Model处理的内容提交给Model，将请求的名字值对中的名字转为小写
	 * 
	 * @param request
	 *            客户端请求
	 * @throws java.lang.Exception
	 */
	public void service(HttpServletRequest request, HttpServletResponse response)
			throws Exception {
		super.service(request, response);
		this.request = request;
		action = request.getParameter("action");
		// 如果有id号等内容，改变模型
		this.changeModel(request, response);
		if (action != null && action.equals("return")) {
			this.getPage().close();
			return;
		}
		// 把请求中的参数转换成hashtable
		Hashtable hashtable = this.getParams(request);
		// 如果不应当校验，或者校验通过了
		if (!this.shouldVerify(request) || this.doVerify(request, hashtable)) {
			((HTMLFormModel) model).updateAttributes(hashtable);
			// confirm时关闭窗口
			if (action != null && (action.equals("confirm")||action.equals("tijiao"))) {
				this.getPage().refresh();
				this.getPage().close();
			}
		}
	}

	private boolean checkDate(Hashtable ht) {
		LinkedList ls = ExtendElement.findElements(this.getElement(),
				"startdate", "startdate");
		if (ls.size() > 0) {
			Element startEle = (Element) ls.get(0);
			ls = ExtendElement.findElements(this.getElement(), "enddate",
					"enddate");
			if (ls.size() > 0) {
				Element endEle = (Element) ls.get(0);
				String startName = startEle.getAttribute("name");
				String endName = endEle.getAttribute("name");
				String startDate = (String) ht.get(startName);
				String endDate = (String) ht.get(endName);
				return checkDate(startDate, endDate, true);
			}
		}
		ls = ExtendElement.findElements(this.getElement(), "starttime",
				"starttime");
		if (ls.size() > 0) {
			Element startEle = (Element) ls.get(0);
			ls = ExtendElement.findElements(this.getElement(), "endtime",
					"endtime");
			if (ls.size() > 0) {
				Element endEle = (Element) ls.get(0);
				String startName = startEle.getAttribute("name");
				String endName = endEle.getAttribute("name");
				String startDate = (String) ht.get(startName);
				String endDate = (String) ht.get(endName);
				return checkDate(startDate, endDate, false);
			}
		}
		return true;
	}

	private boolean checkDate(String startDate, String endDate, boolean isDate) {
		if (startDate == null || endDate == null) {
			return true;
		}
		if (startDate.equals("") || endDate.equals("")) {
			return true;
		}
		if (isDate) {
			String s = startDate.substring(0, 4) + startDate.substring(5, 7)
					+ startDate.substring(8, 10);
			String e = endDate.substring(0, 4) + startDate.substring(5, 7)
					+ startDate.substring(8, 10);
			int start = Integer.parseInt(s);
			int end = Integer.parseInt(e);
			if (start - end >= 0) {
				return true;
			}
		} else {
			String s = startDate.substring(0, 4) + startDate.substring(5, 7)
					+ startDate.substring(8, 10) + startDate.substring(11, 13)
					+ startDate.substring(14, 16);
			String e = endDate.substring(0, 4) + endDate.substring(5, 7)
					+ endDate.substring(8, 10) + endDate.substring(11, 13)
					+ endDate.substring(14, 16);
			long start = Long.parseLong(s);
			long end = Long.parseLong(e);
			if (start - end >= 0) {
				return true;
			}
		}
		return false;
	}

	/**
	 * 根据元素的类型，设置元素的值
	 * 
	 * @param dealElement
	 *            元素
	 * @throws Exception
	 */
	protected void setFieldValue(Element dealElement) throws Exception {
		// 如果声明了不更新，证明该值是由子组件更新了，不再重复更新
		if (dealElement.hasAttribute("notupdate")) {
			return;
		}
		// 取得属性名
		String objectName = this.getAttributeName(dealElement);
		// 取得属性值
		String objectValue = this.getValue(objectName);
		// 格式化
		objectValue = FormatFactory.getInstance().format(objectValue,
				dealElement);
		// 如果是金额
		String money = dealElement.getAttribute("money");
		if (money != null && money.equals("money")) {
			try {
				// 转换成两位小数表示方式
				double ivalue = Double.parseDouble(objectValue);
				ivalue = Math.round(ivalue * 100) / 100.0;
				objectValue = ivalue + "";
			} catch (NumberFormatException ex) {
			}
		}
		// 取得输入筐类型
		String tagName = dealElement.getTagName();
		// 如果是输入筐
		if (tagName.toLowerCase().equals("input")) {
			// 取得输入筐类型
			String objectType = dealElement.getAttribute("type");
			// 如果是签名元素
			if (this.isSignElement(dealElement)) {
				// 对签名元素进行处理
				this.setSighElementValue(dealElement, objectValue);
			}
			// 如果是密码 框
			else if (objectType.toLowerCase().equals("password")) {
				// objectValue = "******";
				dealElement.setAttribute("value", objectValue);
			}
			// 如果是input筐
			else if (objectType.toLowerCase().equals("")
					|| objectType.toLowerCase().equals("text")
					|| objectType.toLowerCase().equals("hidden")) {
				// 给input筐设置值
				dealElement.setAttribute("value", objectValue);
			}
			// 如果是file类型
			else if (objectType.toLowerCase().equals("file")) {
			}
			// 如果是radio buttons或者checkbox
			else if (objectType.toLowerCase().equals("radio")
					|| objectType.toLowerCase().equals("checkbox")) {
				// 如果值是真
				if (objectValue.toLowerCase().equals("true")) {
					// 设置输入筐为选中状态
					dealElement.setAttribute("checked", "true");
				}
				// 否则
				else {
					// 设置输入筐为非选中状态
					dealElement.removeAttribute("checked");
				}
			}
			// 否则，如果是button
			else if (objectType.toLowerCase().equals("button")) {
				// 不处理
			}
		}
		// 如果是签名元素
		else if (this.isSignElement(dealElement)) {
			// 对签名元素进行处理
			this.setSighElementValue(dealElement, objectValue);
		}
		// 否则，如果是textarea
		else if (tagName.toLowerCase().equals("textarea")) {
			// 设置textarea内容
			setTextareaValue(dealElement, objectValue);
		}
		// 否则，是选择框
		else if (tagName.toLowerCase().equals("select")) {
			// 设置选择框内容
			setSelectValue(dealElement, objectName);
		}
		// 如果是查看详细信息
		if (readOnlyShow) {
			dealReadOnly(dealElement, objectValue);
		}
	}

	/**
	 * 对只读处理
	 * 
	 * @param dealElement
	 *            要处理的元素
	 * @param 元素所对应的属性值
	 */
	private void dealReadOnly(Element dealElement, String objectValue) {
		String tag = dealElement.getTagName();
		// 如果是textarea
		if (tag.equals("textarea")) {
			// 得到父元素
			Node oldParent = dealElement.getParentNode();
			// 复制父元素，不带孩子
			Node newParent = oldParent.cloneNode(false);
			// 去回车和换行
			StringTokenizer t = new StringTokenizer(objectValue, "\n\r");
			while (t.hasMoreElements()) {
				Object o = t.nextElement();
				newParent.appendChild(((HTMLPage) this.getPage()).getDocument()
						.createTextNode("　" + o.toString()));
				if (!o.toString().equals("")) {
					newParent.appendChild(((HTMLPage) this.getPage())
							.getDocument().createElement("br"));
				}
			}
			// 用新父元素替换旧父元素
			oldParent.getParentNode().replaceChild(newParent, oldParent);
		}
		// 否则，如果是input
		else if (tag.equals("input")) {
			String type = dealElement.getAttribute("type").toLowerCase();
			// 如果是文本筐
			if (type == null || type.equals("") || type.equals("text")) {
				// 替换输入筐为纯文本
				Node node = this.getPage().getDocument().createTextNode(
						objectValue);
				dealElement.getParentNode().replaceChild(node, dealElement);
			}
			// 如果是文件筐
			else if (type != null && type.toLowerCase().equals("file")) {
				// 替换输入筐为纯文本
				String css = objectValue
						.substring(objectValue.indexOf('_') + 1);
				Node node = this.getPage().getDocument().createTextNode(css);
				Node parent = dealElement.getParentNode();
				parent.removeChild(dealElement); /* 去掉file文件筐 */
				parent.replaceChild(node, parent.getChildNodes().item(0)); /* 把增加的text说明文字替换掉 */
			}
			// 否则，如果是checkbox
			else if (type != null && type.equals("checkbox")) {
				// 设置为只读
				dealElement.setAttribute("readonly", "readonly");
			}
			// 否则，如果是密码框
			else if (type != null && type.equals("password")) {
				// 替换输入筐为纯文本
				Node node = this.getPage().getDocument().createTextNode(
						objectValue);
				dealElement.getParentNode().replaceChild(node, dealElement);
			}
		}
		// 否则，如果是图片按钮
		else if (tag.equals("img")) {
			// 不处理
			return;
		}
		// 否则
		else {
			// 替换输入筐为纯文本
			Node node = this.getPage().getDocument()
					.createTextNode(objectValue);
			dealElement.getParentNode().replaceChild(node, dealElement);
		}
	}

	/**
	 * 取得属性名
	 * 
	 * @param dealElement
	 *            要处理的元素
	 * @return 属性名
	 */
	private String getAttributeName(Element dealElement) {
		// 取得属性名
		String objectName = dealElement.getAttribute("name");
		// 如果没有属性名
		if (objectName == null) {
			// 抛出没有属性错误
			throw new RuntimeException("模板文件错误，要处理的元素没有名称");
		}
		return objectName;
	}

	/**
	 * 设置文本框内容
	 * 
	 * @param dealElement
	 *            要处理的元素
	 * @param objectValue
	 *            要处理的元素值
	 */
	public void setTextareaValue(Element dealElement, String objectValue)
			throws Exception {
		// 去回车和换行
		objectValue = objectValue.replaceAll("\n", "");
		ExtendElement.removeChilds(dealElement);
		// 插入文本内容
		dealElement.appendChild(((HTMLPage) this.getPage()).getDocument()
				.createTextNode(objectValue));
	}

	/**
	 * 设置选择框内容
	 * 
	 * @param objectName
	 *            要设置的选择框名称
	 */
	public void setSelectValue(Element dealElement, String objectName)
			throws Exception {
		List list = new LinkedList();
		Iterator options = null;
		list = SelectContentFactory.getInstance().getOptions(dealElement,
				this.request,((HTMLFormModel) this.model).getAttributes());
		// 否则
		if (list == null || list.isEmpty()) {
			// 得到选择项内容
			options = ((HTMLFormModel) this.model).getOptions(objectName
					.toLowerCase());
		} else {
			options = list.iterator();
		}
		if (options != null) {
			ExtendElement.setSelectValue(options, dealElement);
		}
		setDefaultValue(dealElement, objectName);
	}

	/**
	 * 如果是被选中的，设置selected选项
	 */
	public void setDefaultValue(Element dealElement, String objectName)
			throws Exception {
		// 得到属性值
		String value = this.getValue(objectName);
		NodeList nodelist = dealElement.getChildNodes();
		for (int i = 0; i < nodelist.getLength(); i++) {
			// 是OPTION元素
			if (nodelist.item(i).getNodeType() == Node.ELEMENT_NODE) {
				Element element = (Element) nodelist.item(i);
				Text text = (Text) ExtendElement.findElementContext(element)
						.get(0);
				String context = (String) text.getData();
				if (context.equals(value)) {
					element.setAttribute("selected", "selected");
				} else {
					element.removeAttribute("selected");
				}
			}
		}
	}

	/**
	 * 得到对象值
	 * 
	 * @param objectName
	 *            属性名
	 * @return 属性值
	 */
	private String getValue(String objectName) {
		String objectValue = "";
		try {
			// 取得属性值
			Hashtable hashtable = ((HTMLFormModel) model).getAttributes();
			objectValue = (String) hashtable.get(objectName.toLowerCase());
			// 如果没有属性值
			if (objectValue == null || objectValue.trim().equals("")) {
				// 设置属性值为空串
				objectValue = "";
			}
		} catch (Exception e) {
			objectValue = "";
		}
		// 如果是只读，把""转换成" "(全角空格)，以优化表格显示
		if (readOnlyShow && objectValue.equals("")) {
			objectValue = "　";
		}
		return objectValue;
	}

	/**
	 * 得到需要处理的元素
	 */
	public LinkedList getDealElements() {
		return this.dealElements;
	}

	/**
	 * 使页面上的带有属性的按钮失效
	 */
	public void setButtonElementsAbate() {
		LinkedList abateElement = com.browsesoft.ExtendElement.findElements(
				element, "showtime", "abate");
		for (int i = 0; i < abateElement.size(); i++) {
			((Element) abateElement.get(i)).setAttribute("onclick",
					"showTimeAbate()");
		}
	}

	/**
	 * 删除页面上的确定按钮
	 */
	private void removeConfirmButton() {
		// 找按钮上有confrim标记的元素
		LinkedList elements = ExtendElement.findElements(element, "confirm",
				"confirm");
		// 如果有confrim标记
		if (elements.size() > 0) {
			ExtendElement.removeElement(elements);
		}
	}

	/**
	 * 处理日历选择
	 */
	public void setCalendar() throws Exception {
		// 定义链表保存所有待处理的以元素
		LinkedList dealElements = new LinkedList();
		// 获得所有的日历元素
		dealElements = ExtendElement.findElements(element, "calendar",
				"calendarbutton");
		// 把日历元素链表转换成迭代
		Iterator iElements = dealElements.iterator();
		// 对每一个日历元素进行处理
		while (iElements.hasNext()) {
			Element e = (Element) iElements.next();
			String onclick = e.getAttribute("onclick");
			onclick = onclick.replaceAll("#parentcomponent#", this.getName());
			e.setAttribute("onclick", onclick);
		} // end while
	}

	/**
	 * 处理默认日历
	 */
	public void setDefaultCalendar() throws Exception {
		throw new UnsupportedOperationException();
	}

	/**
	 * 是否检验通过
	 * 
	 * @return 检验通过
	 * @throws Exception
	 */
	public boolean verify(HttpServletRequest request, Hashtable hashtable)
			throws Exception {
		boolean result = true;
		// 得到校验工厂
		VerifyFactory manager = (VerifyFactory) ManagerGroup.getManagerGroup()
				.getManager("verify");
		// 得到校验器
		this.verifytools = manager.getVerifyTools();
		// 对于每一个校验器
		Iterator iter = this.verifytools.iterator();
		while (iter.hasNext()) {
			Object obj = iter.next();
			if (obj instanceof VerifyTool) {
				VerifyTool fieldVerify = (VerifyTool) obj;
				// 清除错误列表
				fieldVerify.getErrorList().clear();
				// 得到校验标记名
				String key = fieldVerify.getKey();
				// 对于每一个要处理的元素
				Iterator ite = this.dealElements.iterator();
				while (ite.hasNext()) {
					Element element = (Element) ite.next();
					// 得到字段名
					String name = element.getAttribute("name");
					// 得到用户输入的值
					String inputValue = (String) hashtable.get(name);
					// 得到校验标记值
					String value = element.getAttribute(key);
					// 如果校验标记值不为空
					if (value != null && !value.equals("")) {
						// 如果校验不通过
						if (!fieldVerify.verify(request, element, inputValue)) {
							result = false;
						}
					}
				}
			} else if (obj instanceof ObjectVerifyTool) {
				ObjectVerifyTool objVerify = (ObjectVerifyTool) obj;
				// 清除错误列表
				objVerify.getErrorList().clear();
				// 对于整个form元素进行校验
				// 如果校验不通过
				if (!objVerify.verify(request, this.getModel(), hashtable, this
						.getElement()))
					result = false;
			}
		}
		return result;
	}

	/**
	 * 设置提示
	 */
	public String getHint(String hint) {
		// 对于每一个检验器
		Iterator iter = this.verifytools.iterator();
		while (iter.hasNext()) {
			Object verify = iter.next();
			if (verify instanceof VerifyTool) {
				VerifyTool tool = (VerifyTool) verify;
				// 设置页面的错误列表
				// 如果错误列表不为空
				if (tool.getErrorList().size() > 0) {
					this.getPage().errorList.addAll(tool.getErrorList());
					// 得到提示信息
					String str = Tools.LinkedListTostring(tool.getErrorList())
							+ tool.getHint();
					hint += str;
				}
			} else if (verify instanceof ObjectVerifyTool) {
				ObjectVerifyTool tool = (ObjectVerifyTool) verify;
				// 设置页面的错误列表
				// 如果错误列表不为空
				if (tool.getErrorList().size() > 0) {
					this.getPage().errorList.addAll(tool.getErrorList());
					// 得到提示信息
					String str = Tools.LinkedListTostring(tool.getErrorList())
							+ tool.getHint();
					hint += str;
				}
			}
		}
		return hint;
	}

	/**
	 * 如果是签名元素,不处理
	 * 
	 */
	public boolean isSignElement(Element elem) {
		// 得到该元素名称
		String name = elem.getAttribute("name");
		// 如果是签名元素要处理的元素
		if (name != null && this.signsList.contains(name)) {
			return true;
		}
		return false;
	}

	/**
	 * 得到签名元素要处理的元素名称集和
	 */
	public LinkedList getSingElementNames() {
		LinkedList result = new LinkedList();
		// 得到所有带sign=sign的元素
		LinkedList list = ExtendElement.findElements(this.element, "sign",
				"sign");
		// 为了找到所有签名按钮要处理的元素
		Iterator iter = list.iterator();
		while (iter.hasNext()) {
			// 得到签名按钮
			Element e = (Element) iter.next();
			// 得到其elementname属性值
			String elementName = e.getAttribute("elementname");
			// 如果有
			if (elementName != null && !elementName.equals("")) {
				result.add(elementName);
			}
		}
		return result;
	}

	/**
	 * 对签名元素进行处理
	 * 
	 * @param Element
	 *            要处理的元素
	 * @param value
	 *            值
	 */
	private void setSighElementValue(Element e, String value) {
		ExtendElement.removeChilds(e);
		e.setAttribute("wrap", "off");
		Node carriage = e.getOwnerDocument().createTextNode("\n");
		// 将值分割
		LinkedList list = Tools.stringToLinkedList(value);
		Iterator iter = list.iterator();
		while (iter.hasNext()) {
			// 得到一项值
			String oneValue = (String) iter.next();
			Node one = e.getOwnerDocument().createTextNode(oneValue);
			e.appendChild(one);
			e.appendChild(carriage.cloneNode(true));
		}
	}

	private void setValue() {
		// 取得页面中value有值得元素
		// 放入model中
		Iterator it = ExtendElement.getElementsByInclude(element, "savevalue",
				"savevalue").iterator();
		while (it.hasNext()) {
			Element valueElement = (Element) it.next();
			String value = valueElement.getAttribute("value");
			if (value != null && !value.equals("")) {
				if (model instanceof SimpleEntity) {
					((SimpleEntity) model).getAttributes().put(
							valueElement.getAttribute("name"),
							valueElement.getAttribute("value"));
				}
			}
		}
	}

	/**
	 * 判断该元素是否是要从其他地方获得返回值的元素
	 */
	private boolean isOtherElement(Element elem) {
		Iterator iter = this.valueFromOtherElemS.iterator();
		while (iter.hasNext()) {
			Element e = (Element) iter.next();
			String onclick = e.getAttribute("onclick");
			if (onclick.indexOf(elem.getAttribute("name")) != -1) {
				return true;
			}
		}
		return false;
	}

	public boolean isReadOnlyShow() {
		return readOnlyShow;
	}

	/**
	 * 调度过程
	 * 
	 * @throws Exception
	 * 
	 */
	public void dispatch(HttpServletRequest request,
			HttpServletResponse response) throws Exception {
		super.dispatch(request, response);
		if (model instanceof AdvancedSimpleEntity) {
			AdvancedSimpleEntity entity = (AdvancedSimpleEntity) model;
			entity.expressionDispose();
		}
	}
}